// 批次管理相关API接口
import { get, post, put, del, upload, download } from '../utils/request'
import { addBatchDefaults, processBatchesResponse } from '../utils/batchUtils'

/**
 * 获取所有批次列表
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.pageSize - 每页数量，默认20
 * @param {string} params.brand - 品牌筛选
 * @param {string} params.season - 季次筛选
 * @param {string} params.status - 状态筛选
 * @param {boolean} params.showArchived - 是否显示归档批次
 * @returns {Promise<Object>} 批次列表和总数
 */

export const getBatches = async (params = {}) => {
  const response = await get('/batches', params)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return processBatchesResponse(data)
}

/**
 * 根据ID获取批次详情
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 批次详情
 */
export const getBatchById = async batchId => {
  const response = await get(`/batches/${batchId}`)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 获取所有品牌列表
 * @returns {Promise<Array>} 品牌列表
 */
export const getBrands = async () => {
  const response = await get('/brands')
  // 如果响应有 data 字段，使用 data 字段的内容
  return response.data || response
}

/**
 * 获取所有季次列表
 * @returns {Promise<Array>} 季次列表
 */
export const getSeasons = async () => {
  const response = await get('/seasons')
  // 如果响应有 data 字段，使用 data 字段的内容
  return response.data || response
}

/**
 * 创建新批次
 * @param {Object} batchData - 批次数据
 * @param {string} batchData.name - 批次名称
 * @param {string} batchData.brand - 品牌
 * @param {string} batchData.season - 季次
 * @returns {Promise<Object>} 创建的批次
 */
export const createBatch = async batchData => {
  const response = await post('/batches', batchData)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 更新批次信息
 * @param {string} batchId - 批次ID
 * @param {Object} batchData - 更新的批次数据
 * @returns {Promise<Object>} 更新后的批次
 */
export const updateBatch = async (batchId, batchData) => {
  const response = await put(`/batches/${batchId}`, batchData)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 删除批次
 * @param {string} batchId - 批次ID
 * @returns {Promise<boolean>} 删除结果
 */
export const deleteBatch = async batchId => {
  return del(`/batches/${batchId}`)
}

/**
 * 归档批次
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 更新后的批次
 */
export const archiveBatch = async batchId => {
  const response = await put(`/batches/${batchId}/archive`)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 取消归档批次
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 更新后的批次
 */
export const unarchiveBatch = async batchId => {
  const response = await put(`/batches/${batchId}/unarchive`)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 更新向量库
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 更新后的批次
 */
export const updateBatchVectors = async batchId => {
  const response = await post(`/batches/${batchId}/update-vectors`)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 导出批次数据
 * @param {string} batchId - 批次ID
 * @param {string} format - 导出格式 (excel, csv等)
 * @returns {Promise<Blob>} 导出的文件
 */
export const exportBatch = async (batchId, format = 'excel') => {
  return download(`/batches/${batchId}/export`, { format }, `batch_${batchId}.${format}`)
}

/**
 * 获取批次体检报告
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 体检报告数据
 */
export const getBatchHealthReport = async batchId => {
  return get(`/batches/${batchId}/health-report`)
}

/**
 * 停止批次导入
 * @param {string} batchId - 批次ID
 * @returns {Promise<Object>} 更新后的批次
 */
export const stopBatchImport = async batchId => {
  const response = await post(`/batches/${batchId}/stop-import`)
  // 如果响应有 data 字段，使用 data 字段的内容
  const data = response.data || response
  return addBatchDefaults(data || {})
}

/**
 * 导入批次数据
 * @param {string} batchId - 批次ID
 * @param {FormData} formData - 包含文件的表单数据
 * @param {string} importMode - 导入模式
 * @param {Function} onProgress - 上传进度回调函数
 * @returns {Promise<Object>} 导入结果
 */
export const importBatchData = async (batchId, formData, importMode, onProgress) => {
  // 确保导入模式被添加到FormData中
  if (importMode && !formData.has('import_mode')) {
    formData.append('import_mode', importMode)
  }

  return upload(`/batches/${batchId}/import`, formData, {
    onUploadProgress: onProgress,
  })
}

// ==================== 批量操作接口 ====================

/**
 * 批量创建批次
 * @param {Array} batchesData - 批次数据数组
 * @returns {Promise<Object>} 批量创建结果
 */
export const batchCreateBatches = async batchesData => {
  return post('/batches/batch', { batches: batchesData })
}

/**
 * 批量更新批次
 * @param {Array} updateData - 更新数据数组，每个元素包含id和更新数据
 * @returns {Promise<Object>} 批量更新结果
 */
export const batchUpdateBatches = async updateData => {
  return put('/batches/batch', { updates: updateData })
}

/**
 * 批量删除批次
 * @param {Array} batchIds - 批次ID数组
 * @returns {Promise<Object>} 批量删除结果
 */
export const batchDeleteBatches = async batchIds => {
  return del('/batches/batch', { data: { ids: batchIds } })
}

/**
 * 批量归档批次
 * @param {Array} batchIds - 批次ID数组
 * @returns {Promise<Object>} 批量归档结果
 */
export const batchArchiveBatches = async batchIds => {
  return put('/batches/batch/archive', { ids: batchIds })
}

/**
 * 批量更新向量库
 * @param {Array} batchIds - 批次ID数组
 * @returns {Promise<Object>} 批量更新向量库结果
 */
export const batchUpdateVectors = async batchIds => {
  return post('/batches/batch/update-vectors', { ids: batchIds })
}

/**
 * 批量停止导入
 * @param {Array} batchIds - 批次ID数组
 * @returns {Promise<Object>} 批量停止导入结果
 */
export const batchStopImport = async batchIds => {
  return post('/batches/batch/stop-import', { ids: batchIds })
}

/**
 * 批量导出批次
 * @param {Array} batchIds - 批次ID数组
 * @param {string} format - 导出格式
 * @returns {Promise<Blob>} 导出的文件
 */
export const batchExportBatches = async (batchIds, format = 'excel') => {
  return download(
    '/batches/batch/export',
    { ids: batchIds, format },
    `batches_${Date.now()}.${format}`
  )
}

/**
 * 获取批次统计信息
 * @param {Object} params - 查询参数
 * @returns {Promise<Object>} 统计信息
 */
export const getBatchStatistics = async (params = {}) => {
  return get('/batches/statistics', params)
}
